package cn.edu.zzuli.common.utils;

import org.apache.commons.lang3.CharUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

/**
*  敏感词过滤
*/
@Component
public class SensitiveFilter {

    private static final Logger logger = LoggerFactory.getLogger(SensitiveFilter.class);
    private static final String REPLACEMENT = "**";
    private TrieNode rootNode = new TrieNode();

    @PostConstruct // 当容器在实例化这个bean的时候,该方法就会被调用
     public void init(){
        try( InputStream is = this.getClass().getClassLoader().getResourceAsStream("sensitive.txt");
             BufferedReader reader = new BufferedReader(new InputStreamReader(is))){
                 String keyword;
                 while ((keyword=reader.readLine())!=null){
                     // 添加到前缀树
                     this.addKeyword(keyword);
                 }
           }catch (IOException e){
             logger.error("加载敏感词文件失败"+e.getMessage());
                 }
           }
    // 将一个敏感词添加到前缀树中
    private void addKeyword(String keyword){
        TrieNode tempNode = rootNode;
        for (int i = 0; i <keyword.length(); i++) {
              char c = keyword.charAt(i);
              TrieNode subNode = tempNode.getSubNode(c);
          if (subNode == null){
              // 初始化子节点
              subNode = new TrieNode();
              tempNode.addSubNode(c,subNode);
          }
          // 指向子节点，进入下一轮循环
          tempNode = subNode;
          // 设置结束标识
          if (i == keyword.length()-1){
               tempNode.setIskeywordEnd(true);
              }
        }
    }

    /**
     *
     * @param text 过滤前
     * @return
     */
    public String filter(String text){
        if (StringUtils.isBlank(text)){
             return null;
        }
        // 指针1
        TrieNode tempNode = rootNode;
        // 指针2
        int begin = 0;
        // 指针3
        int position = 0;
        // 结果
        StringBuilder sb = new StringBuilder();
    while (position < text.length()) {
        char c = text.charAt(position);
        // 跳过符号
        if (isSymbol(c)) {
           // 若指针1处于根节点,将此符号计入结果,让指针2向下走一步
           if (tempNode == rootNode) {
               sb.append(c);
               begin++;
           }
           // 无论符号在开头或中间,指针3都向下走一步
           position++;
           continue;
          }

         // 检查下级节点
         tempNode = tempNode.getSubNode(c);
         if (tempNode == null) {
             //以begin开头的字符串不是敏感词
             sb.append(text.charAt(begin));
             // 进入下一个位置
             position = ++begin;
             // 重新指向根节点
             tempNode = rootNode;
            } else if (tempNode.isIskeywordEnd()) {
             // 发现敏感词,将begin~position字符串替换掉
             sb.append(REPLACEMENT);
             // 进入下一个位置
             begin = ++position;
             // 重新指向根节点
             tempNode = rootNode;
         } else {
             // 检查下一个字符
             position++; }
       }
           //将最后一批字符计入结果
           sb.append(text.substring(begin));
           return sb.toString();
  }

    //判断是否为符号
    private boolean isSymbol(Character c) {
        return !CharUtils.isAsciiAlphanumeric(c) && (c < 0x2E80 || c > 0x9FFF);
    }

    //描述的是当前前缀树的某一个节点
    private class TrieNode{
    //是否是最后一个节点元素
    private boolean iskeywordEnd= false;
    //子节点key是下级字符，value是下级节点类型
    private Map<Character,TrieNode> subNode = new HashMap<>();

    public boolean isIskeywordEnd() {
        return iskeywordEnd;
    }//标记终结点

    public void setIskeywordEnd(boolean iskeywordEnd) {
        this.iskeywordEnd = iskeywordEnd;
    }

    public void addSubNode(Character c,TrieNode node){
       subNode.put(c,node);
     }

    public TrieNode getSubNode(Character c){
           return subNode.get(c);
     }
   }
}
